home *** CD-ROM | disk | FTP | other *** search
/ The Arsenal Files 8 / The Arsenal Files Collection #8 (Arsenal Computer) (1996).ISO / prg_casm / vidmgr13.zip / VMGROS2.C < prev    next >
C/C++ Source or Header  |  1996-10-03  |  7KB  |  327 lines
  1. /*
  2.  *  VMGROS2.C; VidMgr module for OS/2 compilers.  Release 1.2.
  3.  *
  4.  *  This module written in March 1996 by Andrew Clarke and released to the
  5.  *  public domain.  Last modified in May 1996.
  6.  */
  7.  
  8. #define INCL_KBD
  9. #define INCL_VIO
  10. #define INCL_DOSPROCESS
  11.  
  12. #include <string.h>
  13. #include <os2.h>
  14. #include "vidmgr.h"
  15.  
  16. #ifndef KBDTRF_FINAL_CHAR_IN
  17. #define KBDTRF_FINAL_CHAR_IN  FINAL_CHAR_IN
  18. #endif
  19.  
  20. static void vm_setcursorsize(char start, char end);
  21. static void vm_getcursorsize(char *start, char *end);
  22.  
  23. void vm_init(void)
  24. {
  25.     vm_getinfo(&vm_startup);
  26.     vm_setattr(vm_startup.attr);
  27. }
  28.  
  29. void vm_done(void)
  30. {
  31.     vm_setcursorsize(vm_startup.cur_start, vm_startup.cur_end);
  32. }
  33.  
  34. void vm_getinfo(struct vm_info *v)
  35. {
  36.     v->ypos = vm_wherey();
  37.     v->xpos = vm_wherex();
  38.     v->attr = vm_getattrxy(v->xpos, v->ypos);
  39.     v->height = vm_getscreenheight();
  40.     v->width = vm_getscreenwidth();
  41.     vm_getcursorsize(&v->cur_start, &v->cur_end);
  42. }
  43.  
  44. char vm_getscreenwidth(void)
  45. {
  46.     VIOMODEINFO vi;
  47.     vi.cb = sizeof(VIOMODEINFO);
  48.     VioGetMode(&vi, 0);
  49.     return vi.col;
  50. }
  51.  
  52. char vm_getscreenheight(void)
  53. {
  54.     VIOMODEINFO vi;
  55.     vi.cb = sizeof(VIOMODEINFO);
  56.     VioGetMode(&vi, 0);
  57.     return vi.row;
  58. }
  59.  
  60. short vm_getscreensize(void)
  61. {
  62.     return (short)(vm_getscreenwidth() * vm_getscreenheight() * 2);
  63. }
  64.  
  65. char vm_wherex(void)
  66. {
  67.     USHORT row, col;
  68.     VioGetCurPos(&row, &col, 0);
  69.     return (char)(col + 1);
  70. }
  71.  
  72. char vm_wherey(void)
  73. {
  74.     USHORT row, col;
  75.     VioGetCurPos(&row, &col, 0);
  76.     return (char)(row + 1);
  77. }
  78.  
  79. void vm_gotoxy(char x, char y)
  80. {
  81.     VioSetCurPos((USHORT) (y - 1), (USHORT) (x - 1), 0);
  82. }
  83.  
  84. static void vm_setcursorsize(char start, char end)
  85. {
  86.     VIOCURSORINFO vi;
  87.     vi.yStart = start;
  88.     vi.cEnd = end;
  89.     vi.cx = 0;
  90.     vi.attr = 0;
  91.     VioSetCurType(&vi, 0);
  92. }
  93.  
  94. static void vm_getcursorsize(char *start, char *end)
  95. {
  96.     VIOCURSORINFO vi;
  97.     VioGetCurType(&vi, 0);
  98.     *start = vi.yStart;
  99.     *end = vi.cEnd;
  100. }
  101.  
  102. int vm_kbhit(void)
  103. {
  104.     KBDKEYINFO ki;
  105.     ki.fbStatus = 0;
  106.     KbdPeek(&ki, 0);
  107.     return ki.fbStatus & KBDTRF_FINAL_CHAR_IN;
  108. }
  109.  
  110. int vm_getch(void)
  111. {
  112.     KBDKEYINFO ki;
  113.  
  114.     ki.chChar = 0;
  115.     ki.chScan = 0;
  116.     KbdCharIn(&ki, IO_WAIT, 0);
  117.  
  118.     if (ki.chChar == 0xe0)
  119.     {
  120.         if (ki.chScan)
  121.         {
  122.             ki.chChar = 0;      /* force scan return */
  123.         }
  124.         else
  125.         {                       /* get next block */
  126.             ki.chChar = 0;
  127.             KbdCharIn(&ki, IO_WAIT, 0);
  128.             if (!ki.chScan)
  129.             {                   /* still no scan? */
  130.                 ki.chScan = ki.chChar;  /* move new char over */
  131.                 ki.chChar = 0;  /* force its return */
  132.             }
  133.             else
  134.             {
  135.                 ki.chChar = 0;  /* force new scan */
  136.             }
  137.         }
  138.     }
  139.     if (ki.chScan == 0xe0)
  140.     {
  141.         if (!ki.chChar)
  142.         {
  143.             ki.chScan = 0;
  144.             KbdCharIn(&ki, IO_WAIT, 0);
  145.             if (!ki.chScan)
  146.             {                   /* still no scan? */
  147.                 ki.chScan = ki.chChar;  /* move new char over */
  148.                 ki.chChar = 0;  /* force its return */
  149.             }
  150.             else
  151.             {
  152.                 ki.chChar = 0;  /* force new scan */
  153.             }
  154.         }
  155.         else
  156.         {
  157.             ki.chScan = 0;      /* handle 0xe00d case */
  158.         }
  159.     }
  160.     if (ki.chChar)
  161.     {
  162.         ki.chScan = 0;
  163.     }
  164.  
  165.     return (int)((ki.chScan << 8) + (ki.chChar));
  166. }
  167.  
  168. char vm_getchxy(char x, char y)
  169. {
  170.     char ch;
  171.     USHORT len = 1;
  172.     VioReadCharStr(&ch, &len, (USHORT) (y - 1), (USHORT) (x - 1), 0);
  173.     return ch;
  174. }
  175.  
  176. char vm_getattrxy(char x, char y)
  177. {
  178.     char cell[4];
  179.     USHORT len = 4;
  180.     VioReadCellStr(cell, &len, (USHORT) (y - 1), (USHORT) (x - 1), 0);
  181.     return *(cell + 1);
  182. }
  183.  
  184. void vm_xgetchxy(char x, char y, char *attr, char *ch)
  185. {
  186.     char cell[4];
  187.     USHORT len = 4;
  188.     VioReadCellStr(cell, &len, (USHORT) (y - 1), (USHORT) (x - 1), 0);
  189.     *ch = *cell;
  190.     *attr = *(cell + 1);
  191. }
  192.  
  193. void vm_setcursorstyle(int style)
  194. {
  195.     VIOCURSORINFO vi;
  196.  
  197.     switch (style)
  198.     {
  199.     case CURSORHALF:
  200.         vi.yStart = -50;
  201.         vi.cEnd = -100;
  202.         vi.cx = 0;
  203.         vi.attr = 0;
  204.         VioSetCurType(&vi, 0);
  205.         break;
  206.     case CURSORFULL:
  207.         vi.yStart = 0;
  208.         vi.cEnd = -100;
  209.         vi.cx = 0;
  210.         vi.attr = 0;
  211.         VioSetCurType(&vi, 0);
  212.         break;
  213.     case CURSORNORM:
  214.         vi.yStart = -90;
  215.         vi.cEnd = -100;
  216.         vi.cx = 0;
  217.         vi.attr = 0;
  218.         VioSetCurType(&vi, 0);
  219.         break;
  220.     case CURSORHIDE:
  221.         vi.yStart = -90;
  222.         vi.cEnd = -100;
  223.         vi.cx = 0;
  224.         vi.attr = -1;
  225.         VioSetCurType(&vi, 0);
  226.         break;
  227.     default:
  228.         break;
  229.     }
  230. }
  231.  
  232. void vm_putch(char x, char y, char ch)
  233. {
  234.     VioWrtCharStr(&ch, 1, (USHORT) (y - 1), (USHORT) (x - 1), 0);
  235. }
  236.  
  237. void vm_puts(char x, char y, char *str)
  238. {
  239.     VioWrtCharStr(str, (USHORT) strlen(str), (USHORT) (y - 1), (USHORT) (x - 1), 0);
  240. }
  241.  
  242. void vm_xputch(char x, char y, char attr, char ch)
  243. {
  244.     VioWrtCharStrAtt(&ch, 1, (USHORT) (y - 1), (USHORT) (x - 1), (PBYTE) &attr, 0);
  245. }
  246.  
  247. void vm_xputs(char x, char y, char attr, char *str)
  248. {
  249.     VioWrtCharStrAtt(str, (USHORT) strlen(str), (USHORT) (y - 1), (USHORT) (x - 1), (PBYTE) &attr, 0);
  250. }
  251.  
  252. void vm_putattr(char x, char y, char attr)
  253. {
  254.     VioWrtNAttr((PBYTE) &attr, 1, (USHORT) (y - 1), (USHORT) (x - 1), 0);
  255. }
  256.  
  257. void vm_paintclearbox(char x1, char y1, char x2, char y2, char attr)
  258. {
  259.     char y, cell[2];
  260.     cell[0] = ' ';
  261.     cell[1] = attr;
  262.     for (y = y1; y <= y2; y++)
  263.     {
  264.         VioWrtNCell((PBYTE) &cell, (USHORT) (x2 - x1 + 1), (USHORT) (y - 1), (USHORT) (x1 - 1), 0);
  265.     }
  266. }
  267.  
  268. void vm_paintbox(char x1, char y1, char x2, char y2, char attr)
  269. {
  270.     char y;
  271.     for (y = y1; y <= y2; y++)
  272.     {
  273.         VioWrtNAttr((PBYTE) &attr, (USHORT) (x2 - x1 + 1), (USHORT) (y - 1), (USHORT) (x1 - 1), 0);
  274.     }
  275. }
  276.  
  277. void vm_clearbox(char x1, char y1, char x2, char y2)
  278. {
  279.     char y, ch;
  280.     ch = ' ';
  281.     for (y = y1; y <= y2; y++)
  282.     {
  283.         VioWrtNChar((PBYTE) &ch, (USHORT) (x2 - x1 + 1), (USHORT) (y - 1), (USHORT) (x1 - 1), 0);
  284.     }
  285. }
  286.  
  287. void vm_fillbox(char x1, char y1, char x2, char y2, char ch)
  288. {
  289.     char y;
  290.     for (y = y1; y <= y2; y++)
  291.     {
  292.         VioWrtNChar((PBYTE) &ch, (USHORT) (x2 - x1 + 1), (USHORT) (y - 1), (USHORT) (x1 - 1), 0);
  293.     }
  294. }
  295.  
  296. void vm_gettext(char x1, char y1, char x2, char y2, char *dest)
  297. {
  298.     USHORT width;
  299.     char y;
  300.     width = (USHORT) ((x2 - x1 + 1) * 2);
  301.     for (y = y1; y <= y2; y++)
  302.     {
  303.         VioReadCellStr((PBYTE) dest, &width, (USHORT) (y - 1), (USHORT) (x1 - 1), 0);
  304.         dest += width;
  305.     }
  306. }
  307.  
  308. void vm_puttext(char x1, char y1, char x2, char y2, char *srce)
  309. {
  310.     USHORT width;
  311.     char y;
  312.     width = (USHORT) ((x2 - x1 + 1) * 2);
  313.     for (y = y1; y <= y2; y++)
  314.     {
  315.         VioWrtCellStr((PBYTE) srce, width, (USHORT) (y - 1), (USHORT) (x1 - 1), 0);
  316.         srce += width;
  317.     }
  318. }
  319.  
  320. void vm_horizline(char x1, char x2, char row, char attr, char ch)
  321. {
  322.     char cell[2];
  323.     cell[0] = ch;
  324.     cell[1] = attr;
  325.     VioWrtNCell((PBYTE) &cell, (USHORT) (x2 - x1 + 1), (USHORT) (row - 1), (USHORT) (x1 - 1), 0);
  326. }
  327.